
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Control;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.JTable;
/**
 *
 * @author FIDO 80
 */
public class Control {

    public String getResultadoJotas() {
        return ResultadoJotas;
    }

    public void setResultadoJotas(String ResultadoJotas) {
        this.ResultadoJotas = ResultadoJotas;
    }
    
    int colum;
    int filas;
    int miu;
    Double tao;
    Double l1;
    Double l2;
    Double l3;
    Double l4;
    Double critico;
    Celda[][][] matriz;
    Object[][] indice;
    int[][] indices;
    int sumRTotal;
    int[] sumRColumnas;
    int[] sumRFilas;
    int[][] sumRCeldas;
    int sumMTotal;
    int[][] sumMCeldas;
    String Resultado = "";
    int rCuadrado;
    int ProductoFilasJ;
    EstadisticaJ eJ = new EstadisticaJ();
    EstadisticaK eK = new EstadisticaK();
    int[] Jotas;
    String ResultadoJotas = "";


    public String getResultado() {
        return Resultado;
    }

    public void setResultado(String Resultado) {
        this.Resultado = Resultado;
    }

    public int getColum() {
        return colum;
    }

    public void setColum(int colum) {
        this.colum = colum;
    }

    public int getFilas() {
        return filas;
    }

    public void setFilas(int filas) {
        this.filas = filas;
    }

    public Object[][] getIndice() {
        return indice;
    }

    public void setIndice(Object[][] indice) {
        this.indice = indice;
    }

    public int[][] getIndices() {
        return indices;
    }

    public void setIndices(int[][] indices) {
        this.indices = indices;
    }

    public Double getL1() {
        return l1;
    }

    public void setL1(Double l1) {
        this.l1 = l1;
    }

    public Double getL2() {
        return l2;
    }

    public void setL2(Double l2) {
        this.l2 = l2;
    }

    public Double getL3() {
        return l3;
    }

    public void setL3(Double l3) {
        this.l3 = l3;
    }

    public Double getL4() {
        return l4;
    }

    public void setL4(Double l4) {
        this.l4 = l4;
    }

    public Celda[][][] getMatriz() {
        return matriz;
    }

    public void setMatriz(Celda[][][] matriz) {
        this.matriz = matriz;
    }

    public int getMiu() {
        return miu;
    }

    public void setMiu(int miu) {
        this.miu = miu;
    }

    public int[][] getSumMCeldas() {
        return sumMCeldas;
    }

    public void setSumMCeldas(int[][] sumMCeldas) {
        this.sumMCeldas = sumMCeldas;
    }

    public int getSumMTotal() {
        return sumMTotal;
    }

    public void setSumMTotal(int sumMTotal) {
        this.sumMTotal = sumMTotal;
    }

    public int[][] getSumRCeldas() {
        return sumRCeldas;
    }

    public void setSumRCeldas(int[][] sumRCeldas) {
        this.sumRCeldas = sumRCeldas;
    }

    public int[] getSumRColumnas() {
        return sumRColumnas;
    }

    public void setSumRColumnas(int[] sumRColumnas) {
        this.sumRColumnas = sumRColumnas;
    }

    public int[] getSumRFilas() {
        return sumRFilas;
    }

    public void setSumRFilas(int[] sumRFilas) {
        this.sumRFilas = sumRFilas;
    }

    public int getSumRTotal() {
        return sumRTotal;
    }

    public void setSumRTotal(int sumRTotal) {
        this.sumRTotal = sumRTotal;
    }

    public Double getTao() {
        return tao;
    }

    public void setTao(Double tao) {
        this.tao = tao;
    }
    
    
    public Object[][] creaMatriz (){
        setIndice(new Object[filas][colum]);
        System.out.println("crearMatriz");
        return indice;               
    }
    
     public Double valorCritico(Double lambda1, Double lambda2, Double lambda3, Double lambda4, Double alfa){
        Double valorcritico = lambda1 + ((Math.pow((1-alfa),lambda3)-Math.pow(alfa, lambda4))/lambda2);
        /*int aceptados=0;
        int rechazados = 0;
        for ( int i = 0; i < Jotas.length; i++) {
            if (valorcritico > Jotas[i]){
                aceptados ++; 
            }
            else{
                rechazados ++;
                
            }
            
        }
        System.out.println("el valor critico fue: "+valorcritico+" ");
        System.out.println("hubo "+aceptados+" valores ACEPTADOS");
        System.out.println("hubo "+rechazados+" valores RECHAZADOS");
        */return valorcritico;
     }
        
        
    public void llenadoIndices (JTable tabla){
        indices = new int[filas][colum];
        
        for(int i = 0 ; i < filas ; i++){
           for(int j = 0 ; j < colum ; j++){
               indices[i][j]=Integer.parseInt((String)tabla.getValueAt(i, j));
           }
        }
        try {
            int m = Integer.parseInt(JOptionPane.showInputDialog("Ingrese la cantidad de Iteraciones: "));
            Jotas = new int[m];
            Double[] betas = new Double[filas];
            for (int i = 0; i < filas ; i++) {
                betas[i] = Double.parseDouble(JOptionPane.showInputDialog("Ingrese el Beta para la fila "+i+": "));
                for (int j =0 ; j < colum; j++){
                    l1 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese el LAMBDA 1 de ("+i+","+j+"): "));
                    l2 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese el LAMBDA 2 de ("+i+","+j+"): "));
                    l3 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese el LAMBDA 3 de ("+i+","+j+"): "));
                    l4 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese el LAMBDA 4 de ("+i+","+j+"): "));                 
                }
            }
           
                for (int i = 0; i < m; i++) {
                    
                setMatriz(generadorMatriz(tabla, miu, tao, l1, l2, l3, l4,betas));
                matriz = eJ.Policotomizacion(matriz, tabla);
                matriz = eK.policotomizacion(matriz, tabla);
                calculaSumatorias();
                //System.out.println(rCuadrado+""+""+ProductoFilasJ);
                Jotas[i] = Math.abs(rCuadrado * ProductoFilasJ);        
            }
            for (int i = 0; i < m; i++) {
                System.out.println("Jotas sub "+i+" "+Jotas[i]);
                ResultadoJotas += (Jotas[i]+"\n");
                }
            //CALCULO DE VARIANZA Y LEY DEBIL DE LOS GRANDES NUMEROS
            //MEDIA
            int cantidad =0;
            double media = 0.0;
            for ( int i = 0; i < m; i++) {
                media += Jotas[i];
                cantidad ++;
                }
            media = media / cantidad;
            System.out.println("//////// LA MEDIA ES: "+media+" \\\\\\\\");
            //VARIANZA
            double varianza = 0.0;
            double v = 0.0;
            for ( int i = 0; i < m; i++) {
                v += Math.pow(Jotas[i]- media, 2) ;
                }
            varianza = v/m;
            System.out.println("//////// LA VARIANZA ES: "+varianza+" \\\\\\\\");
            
            BufferedReader lectura = new BufferedReader(new InputStreamReader(System.in));
            Double error;
            Double delta;
            System.out.println("************Ingrese el ERROR : ");
            error = Double.parseDouble(lectura.readLine());
            System.out.println("************ERROR ingresado "+error);
            System.out.println("************Ingrese el DELTA : ");
            delta = Double.parseDouble(lectura.readLine());
            System.out.println("************DELTA ingresado "+delta);
            System.out.println("/*/*/*/*/*/*/*/*/* LA CANTIDAD DE ITERACIONES DEBE SER MAYOR O IGUAL A "
                    +(varianza)/((Math.pow(error, 2))*delta));
            
        } 
        catch (IOException ex) {
            System.out.println("ERROR");
            Logger.getLogger(Control.class.getName()).log(Level.SEVERE, null, ex);
        }
        matriz = eJ.Policotomizacion(matriz, tabla);
        matriz = eK.policotomizacion(matriz, tabla);
        calculaSumatorias();    
    }
    
       
    
//recibe # de filas y columnas y genera el espacio
    public Celda[][][] generadorMatriz(JTable tabla, int miu, Double tao, Double l1, Double l2, Double l3, Double l4, Double[] betas) throws IOException{
        int nColum = tabla.getColumnCount();
        int nFilas = tabla.getRowCount();
        Celda[][][] tmatriz = new Celda[nFilas][nColum][10]; // el 10 es un limite del # de datos por celda
        
        System.out.println("su MIU es "+miu);  
         
        System.out.println("su Tao es "+tao);  
        
        System.out.println("su Lambda 1 es "+l1);
        
        System.out.println("su Lambda 2 es "+l2);
        
        System.out.println("su Lambda 3 es "+l3); 
        
        System.out.println("su Lambda 4 es "+l4); 
        
        for(int i = 0; i < nFilas ;i++){
            Double Beta = betas[i];
             
        
        
            for(int j = 0; j < nColum ;j++){
                String cadena = (String) tabla.getValueAt(i, j); //lee el numero que se ingresa en cada celda en la interfaz (#datos x celda)
                int z = Integer.parseInt(cadena);//convierte los caracteres en enteros
                    for (int k = 0; k < z;k++){//((Integer)tabla.getValueAt(i, j)).intValue(); k++){
                        Random rnd = new Random();
                        Double u;
                        u = (rnd.nextDouble());
                        Double X;
                                            
                        X = miu + Beta + tao + l1 +((Math.pow(u,l3)-(Math.pow(1-u,l4)))/l2);
                        
                    System.out.println((X)+" "+(i)+" "+(j)+" "+(k));
                    Celda tCelda = new Celda();//celda temporal donde llena los valores
                    tCelda.setValor(X);////copia el valor que se ingresa en el pantallazo
                    tCelda.setX(i);
                    tCelda.setY(j);//copia las coordenadas w y z
                    tCelda.setZ(k);
                    tmatriz[i][j][k]=tCelda; //copia la copia en la matriz principal.
                                        
                }
            }
        }
        return tmatriz;
    }
    
    public void calculaSumatorias(){
        sumRColumnas = calcularArregloColumnasJ(matriz, indices, filas, colum);
        for (int j = 0 ; j < colum ; j++){
            System.out.println("<<J>>Sumatoria columna "+j+": "+sumRColumnas[j]);
            Resultado += ("<<J>>Sumatoria columna "+j+": "+sumRColumnas[j]+"\n");
        }
        
        sumRFilas = calcularArregloFilasJ(matriz, indices, filas, colum);
        for (int i = 0 ; i < filas ; i++){
            System.out.println("<<J>>Sumatoria fila "+i+": "+sumRFilas[i]);
            Resultado += ("<<J>>Sumatoria fila "+i+": "+sumRFilas[i]+"\n");
            
        }
        sumRCeldas = eJ.calculoPorCeldas(matriz, indices, colum, filas);
        System.out.println("La sumatoria de los datos por celda de la matriz, aplicando metodo J es: ");
        Resultado += ("La sumatoria de los datos por celda de\n la matriz, aplicando metodo J es: \n");
        for (int i = 0 ; i < filas ; i++){
            for (int j = 0 ; j < colum ; j++){
                System.out.print(sumRCeldas[i][j]+"  ");
                Resultado += (sumRCeldas[i][j]+"  ");
            }
            System.out.println("");
            Resultado += ("\n");
        }
        sumRTotal = eJ.TotalRJ(sumRCeldas, filas, colum);
            System.out.println("La sumatoria de los datos de la matriz, aplicando metodo J es: "+sumRTotal);
            Resultado += ("La sumatoria de los datos de la matriz,\n aplicando metodo J es: "+sumRTotal+"\n\n");
            
        sumRTotal = eJ.TotalRJ(sumRCeldas, filas, colum);
        rCuadrado = eJ.TotalRJPotencia(sumRCeldas, filas, colum);
        ProductoFilasJ = eJ.productoFilas(sumRFilas);
            
        sumRColumnas = calcularArregloColumnasK(matriz, indices, filas, colum);
        for (int j = 0 ; j < colum ; j++){
            System.out.println("<<K>>Sumatoria columna "+j+": "+sumRColumnas[j]);
            Resultado += ("<<K>>Sumatoria columna "+j+": "+sumRColumnas[j]+"\n");
        }
        sumRFilas = calcularArregloFilasK(matriz, indices, filas, colum);
        for (int i = 0 ; i < filas ; i++){
            System.out.println("<<K>>Sumatoria fila "+i+": "+sumRFilas[i]);
            Resultado += ("<<K>>Sumatoria fila "+i+": "+sumRFilas[i]+"\n");
        
        }
            
        sumMCeldas = eK.calculoPorCeldas(matriz, indices, colum, filas);
        System.out.println("La sumatoria de los datos por celda de la matriz, aplicando metodo K es: ");
        Resultado += ("La sumatoria de los datos por celda de\n la matriz, aplicando metodo K es: \n");
        for (int i = 0 ; i < filas ; i++){
            for (int j = 0 ; j < colum ; j++){
                System.out.print(sumMCeldas[i][j]+"  ");
                Resultado += (sumMCeldas[i][j]+"  ");
            }
            System.out.println("");
            Resultado += ("\n");
        }
        sumMTotal = eK.TotalMK(sumMCeldas, filas, colum);
            System.out.println("La sumatoria de los datos de la matriz, aplicando metodo K es: "+sumMTotal);
            Resultado += ("La sumatoria de los datos de la matriz,\n aplicando metodo K es: "+sumMTotal+"\n");
    }
    //recorre las coordenadas, muestra los datos ya ordenado por k o por j al oprimir "Mostrar Datos"
    public String[][] mostrarMatriz(JTable tabla){
        int nColum = tabla.getColumnCount();
        int nFilas = tabla.getRowCount();
        String[][] vistaPrevia = new String[nFilas][nColum];
        for(int i = 0; i < nFilas ;i++){
            for(int j = 0; j < nColum ;j++){
                String cadena = (String) tabla.getValueAt(i, j); 
                int z = Integer.parseInt(cadena);
                String c = "";
                for (int k = 0; k < z;k++){//((Integer)tabla.getValueAt(i, j)).intValue(); k++){
                    c += "  "+matriz[i][j][k].getValor()+"(J "+matriz[i][j][k].getSerie()+") (K "+matriz[i][j][k].getOrden()+")"; 
                }
                vistaPrevia[i][j] = c;
            }
        }
        
        
        return vistaPrevia;
    }
    //calcula las sumas de cada columna de la forma J
    public int[] calcularArregloColumnasJ(Celda[][][] datos, int[][] indices, int filas, int colum){
        System.out.println(matriz[0][0][0].getSerie());
        
        int[] suma = new int[colum];
//        for ( int i = 0 ; i < colum ; i++){
//            suma [i] = eJ.calculoPorColumna(datos, indices, i, colum, filas);//calcula por una colunma (clase estadistica J)
//        }
        return suma;
    }
    //Mismo que el anterior
    public int[] calcularArregloFilasJ(Celda[][][] datos, int[][] indices, int filas, int colum){
        int[] suma = new int[filas];
        EstadisticaJ eJ = new EstadisticaJ();
        for ( int i = 0 ; i < filas ; i++){
            suma [i] = eJ.calculoPorFila(datos, indices, i, colum , filas);
        }
        return suma;
    }

        
    public int[] calcularArregloColumnasK(Celda[][][] datos, int[][] indices, int filas, int colum){
        int[] suma = new int[colum];
        EstadisticaK eK = new EstadisticaK();
        for ( int i = 0 ; i < colum ; i++){
            suma [i] = eK.calculoPorColumna(datos, indices, i, colum, filas);
        }
        return suma;
    }
    
    public int[] calcularArregloFilasK(Celda[][][] datos, int[][] indices, int filas, int colum){
        int[] suma = new int[filas];
        EstadisticaK eK = new EstadisticaK();
        for ( int i = 0 ; i < filas ; i++){
            suma [i] = eK.calculoPorFila(datos, indices, i, colum , filas);
        }
        return suma;
    }
    
    public Control() {
    }
    
}
